#include<thread>
void print1(int& x)
{
	for (; x < 100; ++x)
	{
		cout <<"thread1:" << x << endl;
	}
}

void print2(int& y)
{
	for (; y < 100; ++y)
	{
		cout <<"thread2:"<< y << endl;
	}
}
//int main()
//{
//	int i = 0;
//	thread t1(print1, ref(i));   //必须使用ref(i)才能传过去，或者ref(i)，共有这个i
//	thread t2(print2, ref(i));
//	t1.join();
//	t2.join();
//	cout << "xxxxxxxxxxxxxxxxxxxxxxxxxxx" << endl;
//	return 0;
//}


//int main()
//{
//	int i = 0;
//	thread t1([&i] {
//		for (; i < 100; ++i)
//		{
//			cout << "thread1:" << i << endl;
//		}
//	}); 
//	thread t2([&i] {
//		for (; i < 100; ++i)
//		{
//			cout << "thread2:" << i << endl;
//		}
//	});
//	t1.join();
//	t2.join();
//	cout << "xxxxxxxxxxxxxxxxxxxxxxxxxxx" << endl;
//	return 0;
//}

//int main()
//{
//	//N个线程同时走
//	vector<thread> vTh;
//	int i = 0;
//	cin >> i;
//	vTh.resize(i);
//	int x = 0;
//	int t = 0;
//	for (auto& eth : vTh)
//	{
//		eth = thread([&t,x] {    //线程不允许拷贝构造，允许移动赋值，这是一个移动赋值
//			while(t<1000)
//			{
//				cout << "thread"<<x<<"-->" << t << endl;
//				++t;
//			}
//		});
//		++x;
//	}
//	for (auto& t : vTh)
//	{
//		t.join();
//	}
//	return 0;
//}





//struct ComparePriceLess
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//		return gl._price < gr._price;
//	}
//};
//struct ComparePriceGreater
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//		return gl._price > gr._price;
//	}
//};
//int main()
//{
//	//vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
//	////sort(v.begin(), v.end(), ComparePriceLess());
//	////sort(v.begin(), v.end(), ComparePriceGreater());
//
//	////lambda表达式
//	//sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr) {return gl._price > gr._price; });
//	//sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr) {return gl._price < gr._price; });
//
//	auto res = [](int x, int y) {return x > y; };//生成一个仿函数的类，编译器能看见，只能用auto去接受
//	cout << res(1, 2) << endl;;
//
//
//	return 0;
//}

// 
//int main()
//{
//	int a = 0;
//	int b = 1;
//	auto swap1 = [a, b]()mutable {   //默认的捕捉是传值捕捉，是个const参数，加上mutable可以去掉const属性，
//		int tmp = a;a = b;b = tmp;
//	};
//	auto swap1 = [&a, &b] {   //引用捕捉,可以修改
//		int tmp = a;a = b;b = tmp;
//	};
//	swap1();
//	//所有都捕捉
//	auto swap2 = [&] {   //捕捉前面父作用域的所有变量，引用捕捉
//		int tmp = a;a = b;b = tmp;
//	};
//	auto swap3 = [=] {   //捕捉前面父作用域的所有变量，传值捕捉
//	};
//	//混合捕捉
//	auto swap4 = [=, &a] {   //a引用捕捉,其他的传值捕捉
//		int tmp = a;a = b;
//	};
//	auto swap5 = [&, a] {   //a传值捕捉,其他的引用捕捉
//		int tmp = a;
//	};
//	cout << a << " : " << b << endl;
//	return 0;
//}
//
//class Rate
//{
//public:
//	Rate(double rate) : _rate(rate)
//	{}
//	double operator()(double money, int year)
//	{
//		return money * _rate * year;
//	}
//private:
//	double _rate;
//};
//int main()
//{
//	// 函数对象
//	double rate = 0.49;
//	Rate r1(rate);
//	r1(10000, 2);
//
//	// lambda
//	auto r2 = [=](double monty, int year)->double {return monty * rate * year;
//	};
//	r2(10000, 2);
//	return 0;
//}


////Args:模板参数包    args 是一个函数形参模板包 
//int main()
//{
//
//
//
//
//	return 0;
//}


//可变模板参数
//可以传入多个值进来
//递归终止函数

//void ShowList() //解析参数包
//{
//	cout  << endl;
//}
//// 展开函数
//template <class T, class ...Args>
//void ShowList(T value, Args... args) //args可以接受0---N个参数
//{
//	//cout << sizeof...(args) << endl;
//	cout << value << " ";
//	ShowList(args...);
//}
//int main()
//{
//	ShowList(1);
//	ShowList(1, 'A');
//	ShowList(1, 'A', std::string("sort"));
//	return 0;
//}



template <class T>
//void PrintArg(T t)
int PrintArg(T t)
{
	cout << t << " ";

	return 0;
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
	//int arr[] = { (PrintArg(args), 0)... };
	int arr[] = { PrintArg(args)... };
	cout << endl;
}
//int main()
//{
//	ShowList(1);
//	ShowList(1, 'A');
//	ShowList(1, 'A', std::string("sort"));
//	return 0;
//}


#include<list>

//
//int main()
//{
//	std::list< int > mylist1;
//
//	mylist1.emplace_back();//可以传0个参数，就是匿名构造一个0
//	mylist1.emplace_back(1);//可以传1个参数,但是不能传多个参数
//	mylist1.push_back(2);//可以传0个参数
//
//
//	for (auto e : mylist1)
//		cout<<e << endl;
//	std::list< std::pair<int, char> > mylist;  //对于内置类型，基本没什么区别
//	// emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象,
//	// 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
//	
//	mylist.emplace_back(10, 'a');
//	mylist.emplace_back(20, 'b');              //直接构造
//	mylist.emplace_back(make_pair(30, 'c'));  //构造+拷贝构造
//	mylist.push_back(make_pair(40, 'd'));
//	mylist.push_back({ 50, 'e' });
//	for (auto e : mylist)
//		cout << e.first << ":" << e.second << endl;
//	return 0;
//}
//
int main()
 {
	std::list< std::pair<int, my_string::string> > mylist;
	pair<int, my_string::string> kv(20, "sort");
	mylist.emplace_back(kv);

	mylist.emplace_back(make_pair(20, "sort"));
	mylist.emplace_back(10, "sort");
	
	cout << endl << endl;

	mylist.push_back(kv);   //左值
	mylist.push_back(make_pair(30, "sort"));  //表达式 是个右值
	mylist.push_back({ 40, "sort" });        //右值  这一个列表初始化
	return 0;


}
